fetcher: Hoist core "mirrored request" API to public

This is in preparation for the libcurl port. We're basically making public what
we had internally. The next step here is to create `ostree-fetcher-util.[ch]`
that only operates in terms of this lower level API.

Also drop the `_mirrored` from the function name since it's
the default now.

Closes: #636
Approved by: jlebon

diff --git a/src/libostree/ostree-fetcher.c b/src/libostree/ostree-fetcher.c
index 639421668526d5a3931e8a6d3f2e2a01cfa4b9bd..c69bbefad7a463ff9a1158fbdcc833bb1c06c9b6 100644 (file)
--- a/src/libostree/ostree-fetcher.c
+++ b/src/libostree/ostree-fetcher.c
@@ -1179,17 +1179,16 @@ on_request_sent (GObject        *object,
   g_object_unref (task);
 }
 
-static void
-ostree_fetcher_mirrored_request_internal (OstreeFetcher         *self,
-                                          GPtrArray             *mirrorlist,
-                                          const char            *filename,
-                                          gboolean               is_stream,
-                                          guint64                max_size,
-                                          int                    priority,
-                                          GCancellable          *cancellable,
-                                          GAsyncReadyCallback    callback,
-                                          gpointer               user_data,
-                                          gpointer               source_tag)
+void
+_ostree_fetcher_request_async (OstreeFetcher         *self,
+                               GPtrArray             *mirrorlist,
+                               const char            *filename,
+                               OstreeFetcherRequestFlags flags,
+                               guint64                max_size,
+                               int                    priority,
+                               GCancellable          *cancellable,
+                               GAsyncReadyCallback    callback,
+                               gpointer               user_data)
 {
   g_autoptr(GTask) task = NULL;
   OstreeFetcherPendingURI *pending;
@@ -1205,10 +1204,10 @@ ostree_fetcher_mirrored_request_internal (OstreeFetcher         *self,
   pending->mirrorlist = g_ptr_array_ref (mirrorlist);
   pending->filename = g_strdup (filename);
   pending->max_size = max_size;
-  pending->is_stream = is_stream;
+  pending->is_stream = (flags & OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL) == 0;
 
   task = g_task_new (self, cancellable, callback, user_data);
-  g_task_set_source_tag (task, source_tag);
+  g_task_set_source_tag (task, _ostree_fetcher_request_async);
   g_task_set_task_data (task, pending, (GDestroyNotify) pending_uri_unref);
 
   /* We'll use the GTask priority for our own priority queue. */
@@ -1220,60 +1219,45 @@ ostree_fetcher_mirrored_request_internal (OstreeFetcher         *self,
                            (GDestroyNotify) g_object_unref);
 }
 
-void
-_ostree_fetcher_mirrored_request_with_partial_async (OstreeFetcher         *self,
-                                                     GPtrArray             *mirrorlist,
-                                                     const char            *filename,
-                                                     guint64                max_size,
-                                                     int                    priority,
-                                                     GCancellable          *cancellable,
-                                                     GAsyncReadyCallback    callback,
-                                                     gpointer               user_data)
-{
-  ostree_fetcher_mirrored_request_internal (self, mirrorlist, filename, FALSE,
-                                            max_size, priority, cancellable,
-                                            callback, user_data,
-                                            _ostree_fetcher_mirrored_request_with_partial_async);
-}
-
-char *
-_ostree_fetcher_mirrored_request_with_partial_finish (OstreeFetcher         *self,
-                                                      GAsyncResult          *result,
-                                                      GError               **error)
+gboolean
+_ostree_fetcher_request_finish (OstreeFetcher         *self,
+                                GAsyncResult          *result,
+                                char                 **out_filename,
+                                GInputStream         **out_stream,
+                                GError               **error)
 {
-  g_return_val_if_fail (g_task_is_valid (result, self), NULL);
-  g_return_val_if_fail (g_async_result_is_tagged (result,
-                        _ostree_fetcher_mirrored_request_with_partial_async), NULL);
-
-  return g_task_propagate_pointer (G_TASK (result), error);
-}
+  GTask *task;
+  OstreeFetcherPendingURI *pending;
+  gpointer ret;
+
+  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
+  g_return_val_if_fail (g_async_result_is_tagged (result, _ostree_fetcher_request_async), FALSE);
+
+  /* Special dance to implement
+    enum FetchResult {
+       Filename(String path),
+       Membuf(uint8[])
+    } in Rust terms
+  */
+  task = (GTask*)result;
+  pending = g_task_get_task_data (task);
 
-static void
-ostree_fetcher_stream_mirrored_uri_async (OstreeFetcher         *self,
-                                          GPtrArray             *mirrorlist,
-                                          const char            *filename,
-                                          guint64                max_size,
-                                          int                    priority,
-                                          GCancellable          *cancellable,
-                                          GAsyncReadyCallback    callback,
-                                          gpointer               user_data)
-{
-  ostree_fetcher_mirrored_request_internal (self, mirrorlist, filename, TRUE,
-                                            max_size, priority, cancellable,
-                                            callback, user_data,
-                                            ostree_fetcher_stream_mirrored_uri_async);
-}
+  ret = g_task_propagate_pointer (task, error);
+  if (!ret)
+    return FALSE;
 
-static GInputStream *
-ostree_fetcher_stream_mirrored_uri_finish (OstreeFetcher         *self,
-                                           GAsyncResult          *result,
-                                           GError               **error)
-{
-  g_return_val_if_fail (g_task_is_valid (result, self), NULL);
-  g_return_val_if_fail (g_async_result_is_tagged (result,
-                        ostree_fetcher_stream_mirrored_uri_async), NULL);
+  if (pending->is_stream)
+    {
+      g_assert (out_stream);
+      *out_stream = ret;
+    }
+  else
+    {
+      g_assert (out_filename);
+      *out_filename = ret;
+    }
 
-  return g_task_propagate_pointer (G_TASK (result), error);
+  return TRUE;
 }
 
 guint64
@@ -1322,8 +1306,9 @@ fetch_uri_sync_on_complete (GObject        *object,
 {
   FetchUriSyncData *data = user_data;
 
-  data->result_stream = ostree_fetcher_stream_mirrored_uri_finish ((OstreeFetcher*)object,
-                                                                    result, data->error);
+  (void)_ostree_fetcher_request_finish ((OstreeFetcher*)object,
+                                        result, NULL, &data->result_stream,
+                                        data->error);
   data->done = TRUE;
 }
 
@@ -1356,9 +1341,9 @@ _ostree_fetcher_mirrored_request_to_membuf (OstreeFetcher  *fetcher,
   data.done = FALSE;
   data.error = error;
 
-  ostree_fetcher_stream_mirrored_uri_async (fetcher, mirrorlist, filename, max_size,
-                                   OSTREE_FETCHER_DEFAULT_PRIORITY, cancellable,
-                                   fetch_uri_sync_on_complete, &data);
+  _ostree_fetcher_request_async (fetcher, mirrorlist, filename, 0, max_size,
+                                 OSTREE_FETCHER_DEFAULT_PRIORITY, cancellable,
+                                 fetch_uri_sync_on_complete, &data);
   while (!data.done)
     g_main_context_iteration (mainctx, TRUE);
 

diff --git a/src/libostree/ostree-fetcher.h b/src/libostree/ostree-fetcher.h
index 8e282e24e331b1b24eed7545530256386a1cc6a8..124a02bff4c2ec9a131aec13bbf59aca98a56f90 100644 (file)
--- a/src/libostree/ostree-fetcher.h
+++ b/src/libostree/ostree-fetcher.h
@@ -103,18 +103,25 @@ void _ostree_fetcher_set_extra_headers (OstreeFetcher *self,
 
 guint64 _ostree_fetcher_bytes_transferred (OstreeFetcher       *self);
 
-void _ostree_fetcher_mirrored_request_with_partial_async (OstreeFetcher         *self,
-                                                          GPtrArray             *mirrorlist,
-                                                          const char            *filename,
-                                                          guint64                max_size,
-                                                          int                    priority,
-                                                          GCancellable          *cancellable,
-                                                          GAsyncReadyCallback    callback,
-                                                          gpointer               user_data);
-
-char *_ostree_fetcher_mirrored_request_with_partial_finish (OstreeFetcher *self,
-                                                            GAsyncResult  *result,
-                                                            GError       **error);
+typedef enum {
+  OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL = (1 << 0)
+} OstreeFetcherRequestFlags;
+
+void _ostree_fetcher_request_async (OstreeFetcher         *self,
+                                    GPtrArray             *mirrorlist,
+                                    const char            *filename,
+                                    OstreeFetcherRequestFlags flags,
+                                    guint64                max_size,
+                                    int                    priority,
+                                    GCancellable          *cancellable,
+                                    GAsyncReadyCallback    callback,
+                                    gpointer               user_data);
+
+gboolean _ostree_fetcher_request_finish (OstreeFetcher *self,
+                                         GAsyncResult  *result,
+                                         char         **out_filename,
+                                         GInputStream **out_stream,
+                                         GError       **error);
 
 gboolean _ostree_fetcher_mirrored_request_to_membuf (OstreeFetcher *fetcher,
                                                      GPtrArray     *mirrorlist,

diff --git a/src/libostree/ostree-repo-pull.c b/src/libostree/ostree-repo-pull.c
index 9c99dc4fbde26bac2f333988402d7e95e16f2774..32ad5fc06c7d669b06e6d64b759e669c9157e35b 100644 (file)
--- a/src/libostree/ostree-repo-pull.c
+++ b/src/libostree/ostree-repo-pull.c
@@ -707,8 +707,7 @@ content_fetch_on_complete (GObject        *object,
   OstreeObjectType objtype;
   gboolean free_fetch_data = TRUE;
 
-  temp_path = _ostree_fetcher_mirrored_request_with_partial_finish (fetcher, result, error);
-  if (!temp_path)
+  if (!_ostree_fetcher_request_finish (fetcher, result, &temp_path, NULL, error))
     goto out;
 
   ostree_object_name_deserialize (fetch_data->object, &checksum, &objtype);
@@ -841,8 +840,7 @@ meta_fetch_on_complete (GObject           *object,
   g_debug ("fetch of %s%s complete", checksum_obj,
            fetch_data->is_detached_meta ? " (detached)" : "");
 
-  temp_path = _ostree_fetcher_mirrored_request_with_partial_finish (fetcher, result, error);
-  if (!temp_path)
+  if (!_ostree_fetcher_request_finish (fetcher, result, &temp_path, NULL, error))
     {
       if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
         {
@@ -982,8 +980,7 @@ static_deltapart_fetch_on_complete (GObject           *object,
 
   g_debug ("fetch static delta part %s complete", fetch_data->expected_checksum);
 
-  temp_path = _ostree_fetcher_mirrored_request_with_partial_finish (fetcher, result, error);
-  if (!temp_path)
+  if (!_ostree_fetcher_request_finish (fetcher, result, &temp_path, NULL, error))
     goto out;
 
   fd = openat (_ostree_fetcher_get_dfd (fetcher), temp_path, O_RDONLY | O_CLOEXEC);
@@ -1382,12 +1379,13 @@ enqueue_one_object_request (OtPullData        *pull_data,
   else
     expected_max_size = 0;
 
-  _ostree_fetcher_mirrored_request_with_partial_async (pull_data->fetcher, mirrorlist,
-                                                       obj_subpath, expected_max_size,
-                                                       is_meta ? OSTREE_REPO_PULL_METADATA_PRIORITY
-                                                               : OSTREE_REPO_PULL_CONTENT_PRIORITY,
-                                                       pull_data->cancellable,
-                                                       is_meta ? meta_fetch_on_complete : content_fetch_on_complete, fetch_data);
+  _ostree_fetcher_request_async (pull_data->fetcher, mirrorlist,
+                                 obj_subpath, OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL,
+                                 expected_max_size,
+                                 is_meta ? OSTREE_REPO_PULL_METADATA_PRIORITY
+                                 : OSTREE_REPO_PULL_CONTENT_PRIORITY,
+                                 pull_data->cancellable,
+                                 is_meta ? meta_fetch_on_complete : content_fetch_on_complete, fetch_data);
 }
 
 static gboolean
@@ -1735,13 +1733,14 @@ process_one_static_delta (OtPullData   *pull_data,
         }
       else
         {
-          _ostree_fetcher_mirrored_request_with_partial_async (pull_data->fetcher,
-                                                               pull_data->content_mirrorlist,
-                                                               deltapart_path, size,
-                                                               OSTREE_FETCHER_DEFAULT_PRIORITY,
-                                                               pull_data->cancellable,
-                                                               static_deltapart_fetch_on_complete,
-                                                               fetch_data);
+          _ostree_fetcher_request_async (pull_data->fetcher,
+                                         pull_data->content_mirrorlist,
+                                         deltapart_path, OSTREE_FETCHER_REQUEST_FLAG_ENABLE_PARTIAL,
+                                         size,
+                                         OSTREE_FETCHER_DEFAULT_PRIORITY,
+                                         pull_data->cancellable,
+                                         static_deltapart_fetch_on_complete,
+                                         fetch_data);
           pull_data->n_outstanding_deltapart_fetches++;
         }
     }